/* -*-jde-*- */
package ui.empresaInterfaz;

import ui.alumnoInterfaz.AlumnoBean;
import app.alumnoe.AlumnoE;
import app.empresa.Empresa;
import app.empresa.Vacante;
import app.mail.Mail;
import app.util.Fecha;
import app.util.appException;
import java.util.Calendar;
import java.util.LinkedList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;

/**
 * Este Managed Bean sirve para emular las actividades de la empresa en sus
 * diferentes páginas de interfaz. Extiende de una clase EmpresaBean que
 * contiene todos los objetos que posee una empresa así como sus métodos de
 * acceso.
 *
 * @author Victor Miguel Peralta Santa Anna
 * @since Enero 2012
 * @version 0.1
 */
@ManagedBean(name = "empresaActionListener")
@SessionScoped
public class EmpresaActionListener extends EmpresaBean {

    /**
     * Creates a new instance of EmpresaActionListener
     */
    public EmpresaActionListener() {
        EmpresaBean empresa = (EmpresaBean) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("empresaBean");
        setContacto(empresa.getContacto());
        setCorreo(empresa.getCorreo());
        setDescripcion(empresa.getDescripcion());
        setIdEmpresa(empresa.getIdEmpresa());
        setNombre(empresa.getNombre());
        setPagweb(empresa.getPagweb());
        setRfc(empresa.getRfc());
        setTelefono(empresa.getTelefono());
        getVacantes().clear();
        for (VacanteBean vacb : empresa.getVacantes()) {
            getVacantes().add(vacb);
        }
        return;
    }

    /**
     * Guarda cambios del perfil de la empresa. Esta información esta desplegada
     * en una sóla página para la empresa
     *
     * @return
     */
    public String guardarCambiosPerfil() {
        try {
            //Conexion con = new Conexion();
            Empresa empresa = new Empresa(Integer.valueOf(getIdEmpresa()));
            empresa.setsCorreo(getCorreo());
            empresa.setsDescripcion(getDescripcion());
            empresa.setsNombre(getNombre());
            empresa.setsNombreContactoEmpresa(getContacto());
            empresa.setsTelefono(getTelefono());
            empresa.setsWeb(getPagweb());
            empresa.save();
            //con.close();

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "Los cambios en el perfil se guardaron exitosamente.",
                    ""));


            return "";
        } catch (appException ex) {
            Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    "Los cambios en el perfil no se han podido guardar.",
                    "Intente de nuevo mas tarde o contacte al administrador en caso de ser necesario."));
            return "";
        }
    }

    public String actualizaListaVacantes() {
        try {
            Empresa empresaBD = new Empresa(Integer.valueOf(getIdEmpresa()));

            getVacantes().clear();
            for (Vacante vacbd : empresaBD.getVacantes()) {
                VacanteBean vacInt = new VacanteBean();
                if (vacbd.getnActivado()) {
                    vacInt.setActivado("Si");
                } else {
                    vacInt.setActivado("No");
                }

                vacInt.setCorreoContacto(vacbd.getsCorreo());
                vacInt.setDescripcion(vacbd.getsDescripcion());
                vacInt.setFechaPublicacion(vacbd.getdFechaPublicacion().toString());
                //vacInt.setFunciones(vacbd.get);
                vacInt.setHtmlDescripcion(vacbd.getHtmlVacante());
                vacInt.setId(vacbd.getnIdVacante() + "");
                vacInt.setInformacion(vacbd.getsInformacion());
                vacInt.setNombreContacto(vacbd.getsNombreCompletoContacto());
                vacInt.setOfrecen(vacbd.getsOfrecen());
                //vacInt.setPracProf(vacbd.get);
                vacInt.setProfBuscados(vacbd.getsProfesionalesBuscados());
                vacInt.setRequisitos(vacbd.getsRequisitos());
                //vacInt.setSalario(vacbd.get);
                vacInt.setTelefono(vacbd.getsTelefono());
                vacInt.setTitulo(vacbd.getsTituloVacante());
                vacInt.setLatitud(vacbd.getLatitud());
                vacInt.setLongitud(vacbd.getLongitud());

                getVacantes().add(vacInt);

            }

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "La lista de Vacantes se ha actualizado.",
                    ""));
            return "";
        } catch (appException ex) {
            Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);
            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    "No se puede actualizar la lista de vacantes.",
                    "Intente de nuevo mas tarde o contacte al administrador en caso de ser necesario."));
            return "";
        }
    }

    /**
     * Usa la vacante seleccionada de la interfaz para obtener los alumnos que
     * se han postulado a esa vacante
     *
     * @return
     */
    public String verPostulantes() {
        FacesContext context = FacesContext.getCurrentInstance();
        if (getVacanteSeleccionada() == null) {
            //No se ha seleccionado una vacante. Lanzar mensaje de error
            FacesMessage message = new FacesMessage();
            message.setSeverity(FacesMessage.SEVERITY_ERROR);
            message.setDetail("Debe seleccionar un registro para ver sus postulantes");
            context.addMessage("form2:vervac", message);
            return "";
        } else {
            try {
                if (getVacanteSeleccionada().getActivado().equalsIgnoreCase("no")) {
                    FacesContext.getCurrentInstance().addMessage(null,
                            new FacesMessage(FacesMessage.SEVERITY_WARN,
                            "Vacante inactiva.",
                            "Podrá verse en las listas de Vacantes una vez que el administrador la apruebe."));

                    return "";
                }

                Vacante vacsel = new Vacante(Integer.valueOf(getVacanteSeleccionada().getId()));
                LinkedList<AlumnoE> alumnos = vacsel.getAlumnosPostulados();
                getAlumnosPorVacante().clear();

                if (alumnos.size() == 0) {
                    FacesMessage message = new FacesMessage();
                    message.setSeverity(FacesMessage.SEVERITY_INFO);
                    message.setDetail("Debe seleccionar un registro para ver sus postulantes");
                    context.addMessage("form2:vervac", message);
                }
                for (AlumnoE alumno : alumnos) {
                    AlumnoBean tmp = new AlumnoBean();
                    tmp.setNombre(alumno.getsNombre());
                    tmp.setApPat(alumno.getsApellidoPaterno());
                    tmp.setApMat(alumno.getsApellidoMaterno());
                    tmp.setHtmlElegido(alumno.getHtmls());
                    tmp.setCarrera(alumno.getScarrera());
                    getAlumnosPorVacante().add(tmp);
                }
                System.out.println(getVacanteSeleccionada().getId());

                return "/Empresas/VerPostulantes.xhtml?faces-redirect=true";
            } catch (appException ex) {
                Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);
                return "";
            }
        }
    }

    /**
     * Crea una nueva vacante para la empresa en cuestión.
     *
     * @return
     */
    public String crearVacante() {
        try {
            boolean beca = false;
            boolean pracProf = false;
            boolean activado = false;
            Calendar cal = Calendar.getInstance();
            Fecha fcreacion = new Fecha(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1, cal.get(Calendar.DATE));


            if (getVacante().getBeca().compareTo("Si") == 0) {
                beca = true;
            }
            if (getVacante().getPracProf().compareTo("Si") == 0) {
                pracProf = true;
            }


            Vacante a = new Vacante(-1,
                    Integer.valueOf(getIdEmpresa()),
                    getVacante().getTitulo(),
                    getVacante().getDescripcion(),
                    getVacante().getProfBuscados(),
                    getVacante().getRequisitos(),
                    getVacante().getOfrecen(),
                    fcreacion,
                    getVacante().
                    getInformacion(),
                    getVacante().getNombreContacto(),
                    getVacante().getCorreoContacto(),
                    getVacante().getTelefono(),
                    getVacante().getLatitud(),
                    getVacante().getLongitud(),
                    beca,
                    pracProf,
                    activado);
            a.save();

            System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + getVacante().getLatitud());
            System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + getVacante().getLongitud());

            Mail.sendAltaVacante(getVacante().getTitulo(), getVacante().getNombreContacto(), getVacante().getCorreoContacto());

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "La vacante se ha creado y está en espera de la autorización del administrador",
                    "Se le informará por correo electrónico de la activación de esta nueva vacante."));

            return "";
        } catch (appException ex) {
            Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    "No se ha podido crear la vacante.",
                    "Intente de nuevo más tarde o contacte al administrador del sistema de ser necesario.."));

            return "";
        }

    }

    public String eliminarVacante() {
        try {
            int id = Integer.valueOf(getVacanteSeleccionada().getId());

            Vacante v = new Vacante(id);

            LinkedList<AlumnoE> listaAlumnos = v.getAlumnosPostulados();

            v.delete();

            Mail.bajaVacanteEmpresa(listaAlumnos);

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_INFO,
                    "No se tienen candidatos postulados a esta vacante.",
                    ""));


            return "";
        } catch (appException ex) {

            Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);

            FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                    "No se ha podido eliminar la vacante.",
                    "Intente de nuevo más tarde o contacte al administrador del sistema de ser necesario.."));

            return "";
        }
    }

    /**
     * Guarda en la base de datos los cambios hechos en la capa de interfaz
     * borrando las vacantes y creando nuevas.
     *
     * @return
     */
    public String guardarCambiosVacantes() {
        try {
            //Conexion con = new Conexion();
            boolean beca = false;
            boolean pracProf = false;
            boolean activado = false;
            Calendar cal = Calendar.getInstance();
            Fecha fcreacion = new Fecha(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1, cal.get(Calendar.DATE));

            for (VacanteBean vac : getVacantes()) {
                if (vac.getBeca().compareTo("Si") == 0) {
                    beca = true;
                }
                if (vac.getPracProf().compareTo("Si") == 0) {
                    pracProf = true;
                }

                if (vac.getId().compareTo("-1") == 0) {//Guardar nueva vacante
                    Vacante a =
                            new Vacante(-1,
                            Integer.valueOf(getIdEmpresa()),
                            vac.getTitulo(),
                            vac.getDescripcion(),
                            vac.getProfBuscados(),
                            vac.getRequisitos(),
                            vac.getOfrecen(),
                            fcreacion,
                            vac.getInformacion(),
                            vac.getNombreContacto(),
                            vac.getCorreoContacto(),
                            vac.getTelefono(),
                            0.15, // latitud
                            0.56, // longitud
                            beca,
                            pracProf,
                            activado);
                    a.save();

                }
            }

            //Se borra las vacantes no requeridas
            Empresa emprBD = new Empresa(Integer.valueOf(getIdEmpresa()));
            for (Vacante vacbd : emprBD.getVacantes()) {
                boolean seDebeBorrar = true;
                for (VacanteBean vac : getVacantes()) {
                    if (vacbd.getnIdUsuario() == Integer.valueOf(vac.getId())) {
                        seDebeBorrar = false;
                    }
                }
                if (seDebeBorrar) {
                    vacbd.delete();
                }
            }

            //con.close();
            return "";
        } catch (appException ex) {
            Logger.getLogger(EmpresaActionListener.class.getName()).log(Level.SEVERE, null, ex);
            return "";
        }
    }
}
